<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  
  <title>JAVA面试基础 | Hui</title>
  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
  <meta name="description" content="基础    异常处理的关键字及作用        try:产生异常        catch:处理异常        finally:不管有没有异常必执行        throws:在方法声明处声明一个异常，调用者必须对这个异常进行处理        throw:在方法内抛出一个异常    抽象类与接口的区别        一个类只可以继承一个抽象类        抽象类即可有方法的实现又可以">
<meta property="og:type" content="article">
<meta property="og:title" content="JAVA面试基础">
<meta property="og:url" content="http://mhuihui.oschina.io/m-pages/2017/01/07/Java面试基础/index.html">
<meta property="og:site_name" content="Hui">
<meta property="og:description" content="基础    异常处理的关键字及作用        try:产生异常        catch:处理异常        finally:不管有没有异常必执行        throws:在方法声明处声明一个异常，调用者必须对这个异常进行处理        throw:在方法内抛出一个异常    抽象类与接口的区别        一个类只可以继承一个抽象类        抽象类即可有方法的实现又可以">
<meta property="og:image" content="https://static.hinpc.com/image/2016/201611-ipad-605420_1920.jpg!width600">
<meta property="og:updated_time" content="2017-02-10T03:36:00.217Z">
<meta name="twitter:card" content="summary">
<meta name="twitter:title" content="JAVA面试基础">
<meta name="twitter:description" content="基础    异常处理的关键字及作用        try:产生异常        catch:处理异常        finally:不管有没有异常必执行        throws:在方法声明处声明一个异常，调用者必须对这个异常进行处理        throw:在方法内抛出一个异常    抽象类与接口的区别        一个类只可以继承一个抽象类        抽象类即可有方法的实现又可以">
<meta name="twitter:image" content="https://static.hinpc.com/image/2016/201611-ipad-605420_1920.jpg!width600">
  
    <link rel="alternate" href="/atom.xml" title="Hui" type="application/atom+xml">
  
  
    <link rel="icon" href="/favicon.png">
  
  
    <link href="//fonts.googleapis.com/css?family=Source+Code+Pro" rel="stylesheet" type="text/css">
  
  <link rel="stylesheet" href="/m-pages/css/style.css">
  

</head>

<body>
  <div id="container">
    <div id="wrap">
      <header id="header">
  <div id="banner"></div>
  <div id="header-outer" class="outer">
    <div id="header-title" class="inner">
      <h1 id="logo-wrap">
        <a href="/m-pages/" id="logo">Hui</a>
      </h1>
      
    </div>
    <div id="header-inner" class="inner">
      <nav id="main-nav">
        <a id="main-nav-toggle" class="nav-icon"></a>
        
          <a class="main-nav-link" href="/m-pages/">Home</a>
        
          <a class="main-nav-link" href="/m-pages/archives">Archives</a>
        
      </nav>
      <nav id="sub-nav">
        
          <a id="nav-rss-link" class="nav-icon" href="/atom.xml" title="RSS Feed"></a>
        
        <a id="nav-search-btn" class="nav-icon" title="Search"></a>
      </nav>
      <div id="search-form-wrap">
        <form action="//google.com/search" method="get" accept-charset="UTF-8" class="search-form"><input type="search" name="q" results="0" class="search-form-input" placeholder="Search"><button type="submit" class="search-form-submit">&#xF002;</button><input type="hidden" name="sitesearch" value="http://mhuihui.oschina.io/m-pages"></form>
      </div>
    </div>
  </div>
</header>
      <div class="outer">
        <section id="main"><article id="post-Java面试基础" class="article article-type-post" itemscope itemprop="blogPost">
  <div class="article-meta">
    <a href="/m-pages/2017/01/07/Java面试基础/" class="article-date">
  <time datetime="2017-01-07T12:11:38.000Z" itemprop="datePublished">2017-01-07</time>
</a>
    
  </div>
  <div class="article-inner">
    
<div class="article-gallery">
  <div class="article-gallery-photos">
    
      <a class="article-gallery-img fancybox" href="https://static.hinpc.com/image/2016/201611-ipad-605420_1920.jpg!width600" rel="gallery_ciyzazarj0004s8vgrqvs7ur0">
        <img src="https://static.hinpc.com/image/2016/201611-ipad-605420_1920.jpg!width600" itemprop="image">
      </a>
    
  </div>
</div>

    
      <header class="article-header">
        
  
    <h1 class="article-title" itemprop="name">
      JAVA面试基础
    </h1>
  

      </header>
    
    <div class="article-entry" itemprop="articleBody">
      
        <hr>
<p>基础<br>    异常处理的关键字及作用<br>        try:产生异常<br>        catch:处理异常<br>        finally:不管有没有异常必执行<br>        throws:在方法声明处声明一个异常，调用者必须对这个异常进行处理<br>        throw:在方法内抛出一个异常<br>    抽象类与接口的区别<br>        一个类只可以继承一个抽象类<br>        抽象类即可有方法的实现又可以有方法声明<br>        当功能需要累积时，用抽象类</p>
<pre><code>    一个类可以实现n个接口
    接口只提供方法的声明不提供方法的实现阶段
    当定义一个标准，功能不需要累积时用接口    
final、finally、finalize的区别
    final:不可变
    finally:异常处理中，有没有异常必执行
    finalize:是类级的一个方法，当虚拟机回收实例前执行
</code></pre><p>技术<br>    jdbc的核心类及作用<br>        DriverManager:得到连接<br>        Connection:真实的数据连接，可以产年PreapredStatement<br>        PreparedStatement:执行sql<br>            executeUpdate:dml<br>            executeQuery:dql<br>        ResultSet:结果集<br>            一行<br>            if(rs.next())<br>            {<br>            }<br>            while(rs.next())<br>            {<br>            }<br>    如何实现从oracle数据库取一行<br>        Class.forName(“Oracle.jdbc.driver.OracleDriver”);<br>        Connection con=DriverManage.getConnection(“jdbc:oracle:thin:@localhost:1521:accp”,”uid”,”pwd”);<br>        PreapredStatement ps=con.prepareStatement(“select * from customer where customerName=?”);<br>        ps.setString(1,”张三”);<br>        ResultSet rs=ps.executeQuery();<br>        Customer customer=new Customer();<br>        if(rs.next())<br>        {<br>            customer.setCustomerName(rs.getString(“customerName”));<br>        }<br>    如何实现一个servlet<br>        类:<br>        public class MyServlet extends HttpServlet<br>        {<br>            //如果超链或表单的method=get时触发<br>            //信息量少，不安全，因在http请求的头<br>            public void doGet(HttpServletRequest request,HttpServletResponse response)<br>            {</p>
<pre><code>        }
        //表单的method=post时触发
        //信息量大，安全，因在http请求的正，一般用这种方法
        public void doPost(HttpServletRequest request,HttpServletResponse response)
        {

        }            
    }
    在web.xml文件中配置
    &lt;servlet&gt;
        &lt;servlet-name&gt;myservlet&lt;/servlet-name&gt;
        &lt;servlet-class&gt;aa.MyServlet&lt;/servlet-class&gt;
    &lt;/servlet&gt;
    &lt;servlet-mapping&gt;
        &lt;servlet-name&gt;myservlet&lt;/servlet-name&gt;
        &lt;url-pattern&gt;/myservlet&lt;/url-pattern&gt;
        &lt;param&gt;
            &lt;param-name&gt;a1&lt;/param-name&gt;
            &lt;param-value&gt;@@@@@@@@@@@@&lt;/param-value&gt;
        &lt;/param&gt;
    &lt;/servlet-mapping&gt;        
servlet的核心类、作用、最重要的方法
    HttpServletRequest:得到客户的请求个信息
        String temp=request.getParameter(&quot;表单域名&quot;)
        String temp[]=request.getParameterValues(&quot;表单域名&quot;);
        request.getSession();
        --转发,在下个页面中保留本页面request,response
        request.getRequestDispatch(&quot;a.jsp&quot;).forward(request,response);

        request.setAttribute(&quot;属性名&quot;,对象)
        request.getAttribute(&quot;属性名&quot;)
    HttpServletResponse:向客户响应信息
        --跳转,在下个页面中不保留本页面request,response
        response.sendRedirect(&quot;a.jsp&quot;);//跳转到下一个页面
        PrintWriter pw=response.getWriter();//向客户打印一个脚本
    HttpSession:一个用户多个页面共享同一变量
        session.setAttribute(&quot;属性名&quot;,&quot;对象&quot;);
        session.getAttribute(&quot;属性名&quot;);            
    ServletContext:全局变量，多个用户多个页面共享同一变量
        servletContext.setAttribute(&quot;属性名&quot;,&quot;对象&quot;);
    ServletConfig:一个servlet的配置
        servletConfig.getParameter(&quot;a1&quot;)
servlet的生命周期
    init
    doGet/doPost
    destroy
servlet的体系结构
    Servlet接口
    GenericServlet:通用的servlet，适合于所有的协议
    HttpServlet:适合于Http协议
    自定义 extends HttpServlet
    {

    }
过滤类的作用
    public class MyFilter implements Filter
    {
        public void doFilter(HttpServletRequest request,HttpServletResponse response,Filter filte)
        {
            request.setCharactorSet(&quot;utf-8&quot;);
            filter.doFilter(request,response);//给真正的处理者
            System.out.println(&quot;aaaaaaaaaaaaaaa&quot;);
        }
    }

    &lt;filter&gt;
        &lt;filter-name&gt;code&lt;/filter-name&gt;
        &lt;filter-class&gt;aa.MyFilter&lt;/filter-class&gt;    
    &lt;/filter&gt;
    &lt;filter-mapping&gt;
        &lt;filter-name&gt;code&lt;/filter-name&gt;
        &lt;url-pattern&gt;/*.do&lt;/url-pattern&gt;
    &lt;/filter-mapping&gt;
转发、跳转、提交、超链的区别
    转发:运行在服务端,下一页面保留当前页面的request、response
    跳转:运行在服务端，下一页面不保留当前页面的request、response


    提交:运行在客户端，向服务器发送请求，提交表单域的内容
    超链:运行在客户端，向服务器发送请求，提交超链信息
jsp中的九大内置对象、作用、方法
    request:HttpServletRequest
    response:HttpServletResponse
    session:HttpSession
    application:ServletContext
    out:向客户端打印文本
    pageContext:当前jsp页面的上下文环境，主要用在自定义标签，可在得到其他的所有内置对象
        pageContext.getSession();
        pageContext.getOut();
        pageContext.getApplication();
        pageContext.forward();//转发到下一个页面
    exception:错误页面的异常
        &lt;%@page contentType=&quot;text/html;charset=utf-8&quot; isErrorPage=&quot;true&quot;%&gt;
    page
        当前jsp页面对应的servlet
    config
        当前jsp页面对应的servlet的ServletConfig
jsp的脚本及作用
    &lt;%%&gt;:java代码
    &lt;%=%&gt;:表达式
    &lt;%!%&gt;:声明，声明一个类级的方法或属性
    &lt;%----%&gt;:注释，在服务端不执行并不返回给客户
    &lt;!--
        &lt;%%&gt;
    --&gt;:&lt;%%&gt;的内容在服务端执知并返回给客户端，客户端不解析
jsp的指令及作用
    &lt;%@page contentType=&quot;text/html;charset=utf-8&quot; language=&quot;java&quot;%&gt;
    &lt;%@taglib uri=&quot;&quot; prefix=&quot;html&quot;%&gt;
    &lt;%@include file=&quot;a.jsp&quot;%&gt;:在编译时将两个jsp合在一起生成源码，
            再生成class文件执行，所以主页面与从页面变量不同重名。
jsp的动作及作用
    &lt;jsp:useBean id=&quot;&quot; class=&quot;&quot; scope=&quot;&quot;/&gt;
        在scope中找名称是id的对象，如果有用已有的，
        如果没有实例一个新的，其名称是id对应的名称
    &lt;jsp:setProperty name=&quot;名称&quot; property=&quot;属性名&quot; value=&quot;值&quot;/&gt;
    &lt;jsp:getProperty name=&quot;名称&quot; property=&quot;属性名&quot;/&gt;
    &lt;jsp:forward page=&quot;a.jsp&quot;/&gt;:转发        
    &lt;jsp:include page=&quot;a.jap&quot;/&gt;: 调用另一个jsp页面，将执行得到的html文本与当前jsp页面生成的文本合在一起。
        是一种调用关系，变量名可以重名。
jsp是不是一个servlet:是
如何用EL语言打印某个作用域的变量
    ${requestScope.对象名.属性名}    
jstl的遍历如何实现
    &lt;c:foreach items=&quot;${sessionScope.对象名}&quot; var=&quot;一个对象&quot;&gt;
    &lt;/c:foreach&gt;
jstl如何实现判断
    &lt;c:if test=&quot;条件&quot;&gt;
    &lt;/c:if&gt;
    &lt;c:choose&gt;
        &lt;c:when test=&quot;条件&quot;&gt;
        &lt;/c:when&gt;
        &lt;c:otherwise&gt;
        &lt;/c:otherwise&gt;
    &lt;/c:choose&gt;
简述设计模式的原则及目的
    原则:
        增加开发，修改关闭
        面向接口或抽象类编程
    目的:
        可扩展
        可维展
简述单例模式(singleton)：整个虚拟机中只有一个实例
    懒汉式:
        用时才得到实例
    饿汉式:
        加载类时实例化一个实例
    特点:
        构造函数是私有
        实例属性名私有、静态
        得到实例的方法公有，静态        
简述模板模式(template)：父类提供抽象方法及具体方法，抽象方法由子类实现，父类的具体方法为子类
        实现的抽象方法提供相关服务，公开的是子类的方法。        
简述工厂模式:(simplefactory)
    角色:
        工厂    
        抽象产品
        具体产品
    作用:
        通过工厂实例化一个具体产品，返回一个抽象产品，实现了部分的开闭原则,    
        增加一个产品时，不用修改客户端，只修改工厂，如果在工厂中用类的返射
        就只改配置文件，不用修改工厂。
简述代理模式(静、动)
    角色:
        接口
        真实对象
        代理对象
    作用:
        代理与真实对象实现了同一接口并将真实对象作为代理的一个属性。
        向客户端公开的代理，当客户端调用代理的方法时，代理调用真实对象的方法,    
        在调用真实对象的方法之前和之后可以做一些处理。        
    动态代理:不用写代理类，虚拟机根据真实对角实现的接口产生一个类，通过
        类实例化一个动态代理，在实例化动态代理时将真实对象
        及处理类注入到动态代理中，向客户端公开的是动态代理，
        当客户端调用动态代理方法时，动态代理根据类的返射得
        到真实对象的Method,调用处理类的invoke方法，将动态代理、
        Method、方法参数传与invoke方法，invoke方法在唤
        起method方法前或后做一些处理。        
简述观察者
    角色:
        观察者(老鼠)
        被观察者(猫)
    实现:
        将观察者聚集到被观察者，当被观察者的状态改变时通知所有的观察者。
    应用:
        awt的事件处理模型
简述架构设计的原则
    上层依赖于下层，尽量减少下层对上层的依赖，层与层之间通过接口相互通信。
简述页面、业务层、dao层、持久层的作用及实现
    总体说明:
        页面:strutsMVC及请求处理过程
        业务层:处理客户的一次操作
        dao:让业务层与持久层强制解藕，当持久层了，对业务层没有任何影响。
        持久层:hibernate jdbc ibatis
    具体实现:
        页面:struts MVC
        业务层:
            IFacade
            Facade
            FacadeFactory
        dao层:
            Dao接口
            DaoImpl:实现
            DaoFactory:产生具体的dao实例，返回dao接口
            AbstactFactory:产生具体的daoFacatory实例，返回AbstractFactory,
                用AbstractFactory代表具体的daoFactory，产生
                具体dao实现，返回dao接口。            
如何通过oracle实向分页处理，在java中怎样调用
    --oracle的实现
    create or replace package myPack
    is
        c_type is ref cursor;
        procedure getPage(p_sql varchar2,pageSize number,currentPage number,c1 out c_type)    ;
    end;

    create or replace package body myPack
    is

        procedure getPage(p_sql varchar2,pageSize number,currentPage number,c1 out c_type)
        is            
            v_sql varchar2(2000);
        begin
            v_sql:=&apos;select * from (&apos;||p_sql||&apos;) where rownum&lt;=&apos;||currentPage*pageSize;
            v_sql:=v_sql||&apos;  minus  &apos;;
            v_sql:=v_sql||&apos;select * from (&apos;||p_sql||&apos;) where rownum&lt;=&apos;||((currentPage1-)*pageSize);
            open c1 for v_sql;
        end;        
    end;

    --java调用oracle
    CallStatement cs=con.preCall(&quot;call {myPack.getPage(?,?,?,?)}&quot;);
    cs.setString(1,&quot;select * from customer&quot;);
    cs.setInt(2,2);
    cs.setInt(3,2);
    cs.registerOutParameter(4,OracleTypes.cursorType);
    cs.execute();
    ResultSet rs=cs.getObejct(4);
    while(rs.next())
    {

    }
如何通过sqlserver分页:
    通过top分页
    --通用代码
    SELECT TOP 页大小 *
    FROM TestTable
    WHERE (ID NOT IN
            (SELECT TOP 页大小*(页数-1) id
             FROM 表
             ORDER BY id))
    ORDER BY ID

    create table aa
    (
        a1 varchar(20) primary key,
        a2 varchar(20)
    );        
    insert into aa values(&apos;a01&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a02&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a03&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a04&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a05&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a06&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a07&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a08&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a09&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a10&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a11&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a12&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a13&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a14&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a15&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a16&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a17&apos;,&apos;11111111111111111&apos;);
    insert into aa values(&apos;a18&apos;,&apos;11111111111111111&apos;);


    SELECT TOP 2  *
    FROM aa
    WHERE a1 NOT IN
            (SELECT TOP 0 a1
             FROM aa
             ORDER BY a1)
    ORDER BY a1

    --第二页
    select top 2 * from aa
    where a1 not in(select top 2 a1 from aa order by a1)
    order by a1;


    --第三页

    select top 2 * from aa
    where a1 not in
    (
        select top 4 a1 from aa order by a1
    )
    order by a1;
    --还有一种方式是通过sqlserver提供的游标分页
如何通过java的session实现分页，java的session分页与数据库分页优缺点。
    java分页:
        通过持久层取出一个表的所有信息放到一个集合中,
        确定一页显示多少行
        根据集合的数量及一页显示多少行的信息确定总共有多少页
        根所客户的请求确定客户需要的当前页
        定位到当前页的第一行(page-1)*pageSize
            每页显示2行，即pageSize=2
            显示第一页
                currentPageFirstRow:第一页的第一行:(1-1)*pageSize
            page=2
                第二页的第一行:(2-1)*pageSize
        取一页信息显示
            for(int i=currentPageFirstRow;i&lt;currentPageFirstRow+pageSize;i++)
            {
                if(i&gt;=list.size())
                {
                    break;
                }
                list.get(i);
            }
    java的session分页与数据库分页优缺点
        java中的sql只第一次时只执行一次，以后不再执行sql，所以速度较快，但很耗内存，
            当数据量很大时不可取。
        数据库分页请求一次sql执行一次，因为要执行sql所以速度慢，不耗内存，当数据量很大时ok        
什么是类的返射?
    通过类说明可以得到类的父类、实现的接口、内部类、构造函数、方法、属性
    并可以根据构造器实例化一个对象，唤起一个方法，取属性值，改属性值。
如何得到一个类说明?
    Class cls=类.class;
    Class cls=对象.getClass();
    Class.forName(&quot;类路径&quot;);
如何得到一个方法并唤起它?
    Class cls=类.class;
    Constructor cons=cls.getConstructor(new Class[]{String.class});
    Object obj=cons.newInstance(new Object[]{&quot;aaa&quot;});
    Method method=cls.getMethod(&quot;方法名&quot;,new Class[]{String.class,Integer.class});
    method.invoke(obj,new Object[]{&quot;aa&quot;,new Integer(1)});        
model2的MVC分别是什么?为什么使用MVC模式
    M(model):业务+dao+持久
    V(view):jsp
    c(control):servlet
    MVC:让界面层与业务层强制解藕，就像旅馆的服务员(control)。
struts的MVC分别代表那些类?
    M:业务+dao+持久
    V:jsp actionForm
    C:
        ActionServlet
        RequestProcessor
        Action
        ActionMapping
        ActionForward            
struts的请求处理过程?
    url.do将请求发给ActionServlet
    ActionServlet转发给RequestProcessor
    RequestProcessor根所url在struts-config.xml找到对应的Action及ActionForm
    如果在相关的作用域中存在ActionForm,RequestProcessor用已有的，如果不存，
    RequestProcesor实例化一个新的，并通过类的返射将表单域的值注入到ActionForm中
    如果存在Action，RequestProcessor用已有的，如果不存在实例化一个新的Action并
    调用Action的execute方法。
    execute方法执行结束时通过ActionMapping找到一个ActionForward转发到另一个jsp页面。
struts的标签库有那些，各有什么作用?
    html:
        &lt;html:form action=&quot;/insert&quot;/&gt;:可以根据url重新生成form，并设置form的名称。
        &lt;action type=&quot;struts.action.InsertAction&quot; path=&quot;/insert&quot; name=&quot;userForm&quot;
            attribute=&quot;userForm&quot; scope=&quot;request&quot;
        &gt;
            &lt;forward path=&quot;succ.jsp&quot; name=&quot;success&quot;/&gt;
        &lt;/action&gt;
    logic:
        &lt;logic:iterator name=&quot;userList&quot; id=&quot;user&quot; scope=&quot;request&quot;/&gt;
        &lt;logic:iterator name=&quot;customer&quot; property=&quot;buies&quot; id=&quot;buy&quot; scope=&quot;request&quot;/&gt;
        &lt;logic:present name=&quot;customer&quot; scope=&quot;request&quot;/&gt;
        &lt;logic:notPresent name=&quot;customer&quot; scope=&quot;request&quot;/&gt;
    bean:
        &lt;bean:define name=&quot;customer&quot; id=&quot;cus&quot; scope=&quot;request&quot;/&gt;
        &lt;bean:define name=&quot;customer&quot; property=&quot;buyies&quot; id=&quot;buies&quot; scope=&quot;request&quot;/&gt;            
    tiles
hibernate的核心类及作用?
    Configuration/AnnotationConfiguration:加载hibernate.cfg.xml及*.hbm.xml文件
        AnnotationConfiguration：即可加载是有注解的类，也可加载*.hbm.xml文件
    SessionFactory:sessionFactory产生具体的session，管理二级缓存，可以有多个实例
        但通过控件整个应用是其实例只有一个。
    Session:对数据库进行增删改查，也是一级缓存，即事务级缓存
        save
        update:如果将要修改的对象在缓存中，会报错，需先查出对象，通过set方法
               修改其值并提交事务。
               如果在缓存中没有可以传一个pojo直接修改
        delete
        get/load(Class cls,Seriable s)
            get:主要用于一级缓存,没查到返回null，返回是一个真实对象
            load:主要用于二级缓存,没查到抛异常，返回是一个代理
        Query query=createQuery(&quot;from Customer where customerName=:aa&quot;);
            query.setString(&quot;aa&quot;,&quot;a1&quot;);
            List list=query.list();
            query.list():如果要用二级缓存，sql相同、数据不能个修改，但
                     sql只执行一次
            query.iterator();其sql执行需两步，第一是取所有主键，
                    第二步是根据每一个主键查找得到一个对象。
                    若没有缓存其会执行&quot;行数+1&quot; 次,若有缓存
                        可以直接取对象。
        //批处理更新
        Query query=createQuery(&quot;delete from  Customer&quot;);
            query.executeUpdate();其不更新缓存
    Transaction;
        Transaction trans=session.beginTransaction();
        trans.commit();        
hibernate的核心配置文件及作用
    hibernate.cfg.xml:数据连接信息及关联的*.hbm.xml
    *.hbm.xml:是一个表与类的具体映射，表名与类名，字段与属性
hibernate对象的生命周期?
    自由:与session没有任何关系
    持久:与session关联
        可以通过set方法直接修改对象在数据库中的值，前提是在事务中
        可以通过get方法取出其关联的另一对象，如果是延迟加载要取其非主键属性值或size();
    游离:被session抛弃(session关闭、session.evict(对象))
         不可以通过set改对象对应的数据库值
         不可以通过get取另一对象的值
如何实现hibernate的onetomany其关键的属性有那些,一般主控方在那边?
    one有一属性是HashSet存放many的所有对象
    many有一属性是具体的一个对象，可以取出它
    inverse:主控方(false)，维护外键列的值，主控方在many这边，
        如果要实现外键的关联必须将被控方作为主控方的属性
    lazy:如果是true是延迟加载，取值只取自己的不取关联的内容。
         如果是false是直接加载，取值不但取当前而且取所有关联的的对象。
    cascade:级联增、删、改
        all:级联增、删、改
        save-update:级联增、改
为什么用hibernate?
    95%
    系统运行的速度慢一些
在hibernate的一个具体配置文件中主键的生成机制有几种，请表述两个最重的。
    native:开发人员在增加对象值时不管主键
        create table a1
        (
            a1 int identity(1,1) primary key,
            a2 varchar2(20)
        )
        insert into a1(a2) values(&apos;aaaaa&apos;);
    assigned:主键手动给
        create table a2
        (
            a1 int  primary key,
            a2 varchar2(20)
        )
        insert into a2(a1,a2) values(1,&apos;aaaaaa&apos;);    
    uuid:hibernate通过一种算法产生一个16位唯一的主键。            
spring的三种注入方式是什么?
    setter
    interface
    constructor
spring的核心类及核类配置文件是什么?
    ApplicationContext ac=new FileXmlApplicationContext(&quot;applicationContext.xml&quot;);
    Object obj=ac.getBean(&quot;id值&quot;);
    applicationContext.xml
spring配置文件中的主要标签是什么?写一个小实例?
    &lt;beans&gt;
        &lt;bean id=&quot;customer&quot; class=&quot;dao.Customer&quot; singleton=&quot;true&quot; init-method=&quot;init1&quot; destroy-method=&quot;destroy1()&quot;&gt;
            &lt;property name=&quot;customerName&quot;&gt;
                &lt;value&gt;张三&lt;/value&gt;
            &lt;/property&gt;
            &lt;property name=&quot;address&quot;&gt;
                &lt;ref local=&quot;address&quot;/&gt;
            &lt;/property&gt;
        &lt;/bean&gt;
        &lt;bean id=&quot;address&quot; class=&quot;dao.Address&quot;&gt;
            &lt;property name=&quot;addressName&quot;&gt;
                &lt;value&gt;深圳&lt;/value&gt;
            &lt;/property&gt;
        &lt;/bean&gt;
    &lt;/beans&gt;
什么是spring的ioc?
    强依赖关系:
        List list=new ArrayList();
    较弱依赖关系
        DocumnetBuilderFactory dbf=DocumentBuilderFactory.newInstance();
        DocumentBuilder db=dbf.newDocumentBuilder();
    最弱依赖关系:
        将类与类依赖关系写到配置文件中，
        程序在运行时动态的加载依赖的类，将一种强依赖关系转化为弱依赖关系。
        是一个超级工厂        
aop是什么?作用?名称及特点?
    aop是面向方面编程是对oop的一种补充，不可以代替oop，共提供一些通用的服务如事务、安全、日志
aop的名称:
    拦截器:代理
    装备:处理类
    目标对象:真实对象
    连接点:连接的是属性还是方法，一般方法
    关切点:要拦截方法的条件
描述struts&amp;spring&amp;hibernate联合的配置文件如何实现?
    sh(spring&amp;hibernate)
    dataSource
    sessionFactory
    userDao:(实现类不是接口)    public class UserDaoImpl extends HibernateDaoSupport implements UserDao
        sessionFactory
    facade:(实现类不是接口)
        userDao
    transactionManager:HibernateTransactionManager
    abstractProxy(abstract=&quot;true&quot;):TransactionProxyFactoryBean 
        transactionManager
        transactionAttributes
                PROPRAGRAM_REQUIRED,readOnly
    facadeProxy(parent=&quot;abstractProxy&quot;):
        target
            facade
    ss(struts&amp;spring)
        在strust中加入一个插件
            类:ContextLoaderPlugIn
            属性:
                contextConfigLocation=/WEB-INF/applicationContext.xml
        struts-config.xml中的每一个action的type不再指向真正的Action，而
            DelegatingActionProxy
        applicationContext.xml中草药
            &lt;bean name=&quot;/insert&quot; class=&quot;struts.action.InsertAction&quot;&gt;
                &lt;property name=&quot;facade&quot;&gt;
                    &lt;ref local=&quot;facadeProxy&quot;/&gt;
                &lt;/property&gt;
            &lt;/bean&gt;
jdbc、hibernate、ibatis各有什么特点及区别
    jdbc(手动):手动写sql，
        在执行dml时手动将对象的每一个值给PreparedStatement，再执行相关的操作
        在执行dql时返回一个ResultSet，手动将ResultSet中的每一个值
            封装到数据类中            
    ibatis(半自动):手动写sql
        在执行dml时直接传一个对象进行增删改
        在执行dql时直接返回一个对象，不用手动封装
    hibernate(全自动):自动生成sql
        在执行dml时直接传一个对象进行增删改
        在执行dql时直接返回一个对象，不用手动封装

什么时候用ibatis:
    1、对性能要求很高，要有高度优化的sql时
    2、没有提供整个表结果，提供了几个select语句
    3、大量的业务写在存储过程中 
ibatis的核心类
    SqlMapClientBuilder:加载sqlmapclient.xml文件及具体的映射文件
    SqlMapClient:相当于hibernate中的session，做数据的增删改查

    Reader reader=Resources.getResourceAsReader(&quot;路径&quot;);
    SqlMapClient smc=SqlMapClientBuilder.buildSqlMapClient(reader);
    smc.queryforObject(&quot;命名空间.标签名&quot;,Object o);
    smc.queryforList(&quot;命名空间.标签名&quot;,Object o);
    smc.delete(&quot;命名空间.标签名&quot;,Object o);
    smc.update(&quot;命名空间.标签名&quot;,Object o);
    smc.insert(&quot;命名空间.标签名&quot;,Object o);        
ibatis的核心配置文件是什么?
    sqlmapclient.xml:说明数据库连接及具体o/r mapping
    buy.xml:具体的o/r mapping说明
描述struts&amp;spring&amp;ibatis联合的配置文件如何实现?
    si(spring ibatis)
        dataSoruce:在sqlmapclient中去掉数据库连接的相关信息
        sqlMapClient:SqlMapClientFactoryBean
            configLocation 
                classpath:sqlmapclient.xml
                /WEB-INF/sqlmapclient.xml
        customerDao
            dataSource
            sqlMapClient
        buyDao 
            dataSource
            sqlMapClient
        facade
            buyDao
            customerDao
        transactionManager:DataSourceTransactionManager
        abstractProxy:TransactionProxyFactoryBean abstract=&quot;true&quot;
            transactionManager
            transacctionAttributes
                PROPAGATION_REQUIRED
                PROPAGATION_REQUIRED,readOnly
        facadeProxy:parent=&quot;abstractProxy&quot;
            target:facade            
当前xml的解析方式有几种，各有什么特点，如何实现?
    dom:document object model(文档对象模型)是树状，每一个节点是一个对象，
        通过节点的方法与属性与外部的程序通信
        解析时将整个xml文件加载到内存中形成一个dom树，可读，可随意跳转
        可写            
        耗内存大，速度慢
        dom的解析
            DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
            DocumentBuilder db=dbf.newDocumentBuilder();
            Document doc=db.parser(&quot;文件&quot;);
    sax:耗内存小，速度快
        边读边解析，只读、只进，不可写

        sax解析:
            处理类:
            public class MakeHandle extends DefaultHander
            {
                public void startDocument();
                public void startElement();
                public void endDocument();
                public void endElement();
                public void chararter();
            }
            解析:
            SaxParserFactory spf=SaxParserFactory.newInstance();
            SaxParser parser=spf.newParser();
            parser.parse(&quot;xml路径&quot;,new MakeHandle());
dom的六大接口及重要方法
    Document:文档本身
        createElement()
        createTextNode()
        NodeList nl=getElementsByTagName(&quot;元素&quot;)
    Node
        Element
            NodeList nl=getElementsByTagName(&quot;元素&quot;)
            appendChild();
            getAttribute(&quot;属性名&quot;)
            setAttribute(&quot;属性名&quot;,&quot;值&quot;)
        Text
            getNodeValue();
    NodeList
        item(i)
        getLength();
    Attribute            
如何生成一个dom对象并将其写到文件中?
    DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
    DocumentBuilder db=dbf.newDocumentBuilder();
    Document doc=db.newDocument(&quot;文件&quot;);
    Element customer=doc.createElement(&quot;customer&quot;);
    Element customerName=doc.createElement(&quot;customerName&quot;);
    Text text=doc.createTextNode(&quot;张三&quot;);
    customerName.appendChild(text);
    customer.appendChild(customerName);
    doc.appendChild(customer);

    TransformerFactory tff=TransformerFactory.newInstance();
    Transformer trformer=tff.newTransformer();
    trformer.transformer(new DOMSource(doc),new ResultStream(&quot;c:\a.xml&quot;));
</code></pre><p>ooad:</p>
<pre><code>什么是模型?模型的原则?　
    模型是现实的浓缩
    作用:
        分析、认识未知的系统
        模型便于决策
        模型可以实现文档化、可视化，便于沟通
    原则:
        模型的好坏决定系统的成败
        模型与现实越接近越说明它的正确性
        模型不止一个，要多个
        模型要根据不同层面的用户，提供不同细节说明。
九大图形(重重)
    use-case:作需求
    类:从需求到设计都是必须的。
    时序:在详细设计阶段，验证系统的正确性，找方法、找类，与时间有关
    协作:在详细设计阶段，说明类与类的交互，与时序图类似，但没有时间概念，
        通过序号说时工作的先后顺序
    活动:分析某一用例的流程，主要用在需求分析阶段
    状态:一个对象在不同的方法下状态转换。
    对象:对象名：类名+下划线
    构建图:不同组件之间的依赖关系
    部署图:与运行应用程序有关的主机之间的关系，找到系统运行的瓶颈。        
类图的元素及关系?(重重)
    元素:
        类
        接口
    关系:
        继承(实线+三角)
        实现接口(虚线+三角)
        依赖(虚线+箭头)
        关联(实线+箭头)
        聚集(实线+空心棱形)
        合成(实线+实心棱形)
use-case的元素及关系?
    元素:
        用例
        角色
        系统边界
    关系:
        用例与用例:
            包含: 必须调用
            扩展:可用可不用
时序图的特点?:找类、找方法、验证系统的正确性
    横轴:
        时间
    纵轴
        对象
        对象的生命周期
三级范式:
    主键(projectID employeeID)
        projectID projectName employeeID employeeName hours 职务  小时工资
    完全依赖
        projectID projectName 
        projectID employeeID hours
        employeeID employeeName 职务  小时工资
    不出现传递依赖            
        projectID projectName 
        projectID employeeID hours
        employeeID employeeName 职务  
        职务    小时工资
e-r图设计的过程
    找实体
    拉关系
    写属性
ooa与ood的区别
    ooa:是面向客户找业务实体，客户可以看懂，分析员也可以看懂
    ood:是对ooa分析得到的业务实体进一步的细化，是开发人员内部使用，是ooa的全集。
面向过程与面向对象的区别
    面向对象:
        在分析、设计、实现都是面向对象的与现实世界相统一所以可以降低复杂度、提高正确性。
        重用性高:继承、业务实体变化不大
        可扩展性高:接口
        可维护性高:层与层之间通过接口通信
    面向过程:
        分析是对象实现是流程与现实世界不符，增大了难度，出现偏差的可能性较大。
        重用性不高
        扩展、维护性差
</code></pre><p>oracle:<br>    oracle的体系结构<br>        数据库(静态)<br>            物理组件:<br>                参数<br>                控制<br>                数据<br>                日志<br>            逻辑:<br>                表空间<br>                段<br>                区<br>                块<br>        实例(动态)<br>            进程<br>                dbwr<br>                lgwr<br>                smon<br>                pmon<br>                ckpt<br>                归档进程<br>            内存<br>                SGA<br>                    数据缓冲<br>                    日志<br>                    共享池<br>                        数据字典<br>                pga:<br>                    一个用户一个<br>    如何实现一个存储过程?如何实现一个函数?<br>        create or replace procedure aa(a1 varchar2,a2 out varchar2,a3 in out varchar2)<br>        is<br>        begin<br>        end;</p>
<pre><code>    create or replace function aa(a1 varchar2) return number
    is
    begin
        return 1;
    end;
oracle的触发器与sql-server的触发器的区别?
    oracle:
        before/after insert/delete/update
        for each statement/row
        新数据:  :new
        老数据:   :old
    sql-server:
        之前之后不可选是由sql-server自己确定的
        for each statement(只有语句级)
        新数据inserted
        老数据deleted
请描述联接、子查询、联合
    联接:多个表列合了一起，会把one复制n-1份
        左:左边所有的右边区配的
        右:右边所有的左边区配的
        select c.*,b.* from customer join buy b on c.customerName=b.customerName;

        select c.*,b.* from customer , buy b where c.customerName=b.customerName;

    子查询:查询套查询，子查询的结果是父查询的条件 
        select * from buy where customerName in(select customerName from customer);    
    联合:多个表的行合了一起
        union
        minus:前一个sql有后一个没有
        intersect:交集            
表分区的特点及优点?
    特点:
        逻辑是一张表，物理上没有存储一起。
    优点:
        速度快
        备份快
        一个分区出现故障与其它分区无关
如何声明、打开、遍历游标?
    declare
        cursor c1 is select * from customer;
        cus customer%rowtype;
    begin
        open c1;
        fetch c1 into cus;
        while(c1%found) loop
            dbms_output.put_line(cus.customerName||&apos;  &apos;||cus.sex);
            fetch c1 into cus;
        end loop;
        close c1;
    end;

    declare 
        type c_type is ref cursor;
        c1 c_type;
    begin
        open c1 for select * from customer;
    end;
如何实现一个包?
    包声明
    包主体
如何备份数据、恢复数据
    在dom命令行中
    exp system/system@aptech owner=scott file=scott1
    imp system/system@aptech file=scott1 full=y ignore=y
    imp system/system@aptech file=scott1  ignore=y fromuser= touser=
</code></pre>
      
    </div>
    <footer class="article-footer">
      <a data-url="http://mhuihui.oschina.io/m-pages/m-pages/2017/01/07/Java面试基础/" data-id="ciyzazarj0004s8vgrqvs7ur0" class="article-share-link">Share</a>
      
      
  <ul class="article-tag-list"><li class="article-tag-list-item"><a class="article-tag-list-link" href="/m-pages/tags/编程/">编程</a></li></ul>

    </footer>
  </div>
  
    
<nav id="article-nav">
  
    <a href="/m-pages/2017/01/08/docker安装教程/" id="article-nav-newer" class="article-nav-link-wrap">
      <strong class="article-nav-caption">Newer</strong>
      <div class="article-nav-title">
        
          docker安装教程
        
      </div>
    </a>
  
  
    <a href="/m-pages/2017/01/06/Ngrok配置详解/" id="article-nav-older" class="article-nav-link-wrap">
      <strong class="article-nav-caption">Older</strong>
      <div class="article-nav-title">Ngrok 配置服务器</div>
    </a>
  
</nav>

  
</article>

</section>
        
          <aside id="sidebar">
  
    

  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Tags</h3>
    <div class="widget">
      <ul class="tag-list"><li class="tag-list-item"><a class="tag-list-link" href="/m-pages/tags/ide/">ide</a></li><li class="tag-list-item"><a class="tag-list-link" href="/m-pages/tags/linux/">linux</a></li><li class="tag-list-item"><a class="tag-list-link" href="/m-pages/tags/编程/">编程</a></li><li class="tag-list-item"><a class="tag-list-link" href="/m-pages/tags/设计/">设计</a></li></ul>
    </div>
  </div>


  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Tag Cloud</h3>
    <div class="widget tagcloud">
      <a href="/m-pages/tags/ide/" style="font-size: 13.33px;">ide</a> <a href="/m-pages/tags/linux/" style="font-size: 16.67px;">linux</a> <a href="/m-pages/tags/编程/" style="font-size: 20px;">编程</a> <a href="/m-pages/tags/设计/" style="font-size: 10px;">设计</a>
    </div>
  </div>

  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Archives</h3>
    <div class="widget">
      <ul class="archive-list"><li class="archive-list-item"><a class="archive-list-link" href="/m-pages/archives/2017/02/">February 2017</a></li><li class="archive-list-item"><a class="archive-list-link" href="/m-pages/archives/2017/01/">January 2017</a></li><li class="archive-list-item"><a class="archive-list-link" href="/m-pages/archives/2016/12/">December 2016</a></li></ul>
    </div>
  </div>


  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Recent Posts</h3>
    <div class="widget">
      <ul>
        
          <li>
            <a href="/m-pages/2017/02/10/go语言学习笔记（四)/">go语言学习笔记（四）</a>
          </li>
        
          <li>
            <a href="/m-pages/2017/02/10/hello-world/">Hello World</a>
          </li>
        
          <li>
            <a href="/m-pages/2017/01/14/go语言学习笔记（三）/">go语言学习笔记（三）</a>
          </li>
        
          <li>
            <a href="/m-pages/2017/01/13/go语言学习笔记（二）/">go语言学习笔记（二）结构体和切片</a>
          </li>
        
          <li>
            <a href="/m-pages/2017/01/12/go语言学习笔记（一）/">go语言开发环境搭建</a>
          </li>
        
      </ul>
    </div>
  </div>

  
</aside>
        
      </div>
      <footer id="footer">
  
  <div class="outer">
    <div id="footer-info" class="inner">
      &copy; 2017 hui<br>
      Powered by <a href="http://hexo.io/" target="_blank">Hexo</a>
    </div>
  </div>
</footer>
    </div>
    <nav id="mobile-nav">
  
    <a href="/m-pages/" class="mobile-nav-link">Home</a>
  
    <a href="/m-pages/archives" class="mobile-nav-link">Archives</a>
  
</nav>
    

<script src="//ajax.googleapis.com/ajax/libs/jquery/2.0.3/jquery.min.js"></script>


  <link rel="stylesheet" href="/m-pages/fancybox/jquery.fancybox.css">
  <script src="/m-pages/fancybox/jquery.fancybox.pack.js"></script>


<script src="/m-pages/js/script.js"></script>

  </div>
</body>
</html>